import java.util.ArrayList;
import java.util.Arrays;
import java.util.*;
import java.util.List;

//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
public class Main {
    public static int i;
    public static int dfs(String s) {
        Stack<Integer> stack = new Stack<>();
        char op = '+';
        int n = s.length();
        while (i < n) {
            int num = 0;
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                while (i < n && s.charAt(i) >= '0' && s.charAt(i) <= '9') {
                    num = num * 10 + (s.charAt(i) - '0');
                    i++;
                }
                if (op == '+')stack.add(num);
                else if (op == '-')stack.add(-num);
                else stack.add(stack.pop() * num);
            } else {
                if (s.charAt(i) == '(') {
                    i++;
                    int x = dfs(s);
                    if (op == '+')stack.add(x);
                    else if (op == '-')stack.add(-x);
                    else stack.add(stack.pop() * x);
                } else if (s.charAt(i) == ')')break;
                else op = s.charAt(i);
                i++;
            }
        }
        int ret = 0;
        while (!stack.isEmpty())ret += stack.pop();
        return ret;
    }
    public int solve (String s) {
        // write code here
        int i = 0;
        return dfs(s);
    }
//    public static ArrayList<Integer> GetLeastNumbers_Solution (int[] input, int k) {
//        // write code here
//        ArrayList<Integer> ret = new ArrayList<>();
//        int n = input.length;
//        if(n < k || k == 0)return ret;
//        PriorityQueue<Integer> q = new PriorityQueue<>((a,b) -> b - a);
//        for(int x : input){
//            if(q.size() < k){
//                q.add(x);
//            }else if(q.peek() > x){
//                q.poll();
//                q.add(x);
//            }
//        }
//        for(int i = 0;i < k;i++)ret.add(q.poll());
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        int[] a = {4,5,1,6,2,7,3,8};
//        GetLeastNumbers_Solution(a,4);
//    }
//    public static String s;
//    public static String dfs(int i, int j, int[][] b){
//        String ret = "";
//        if(i == 0 || j == 0)return ret;
//        if(b[i][j] == 1){
//            ret += dfs(i - 1, j - 1, b);
//            ret += s.charAt(i - 1);
//        }else if(b[i][j] == 2){
//            ret += dfs(i - 1, j, b);
//        }else if(b[i][j] == 3){
//            ret += dfs(i,j - 1, b);
//        }
//        return ret;
//    }
//    public static String LCS (String s1, String s2) {
//        // write code here
//        int n = s1.length(),m = s2.length();
//        int[][] dp = new int[n + 1][m + 1];
//        int[][] b = new int[n + 1][m + 1];
//        for(int i = 1;i <= n;i++){
//            for(int j = 1;j <= m;j++){
//                if(s1.charAt(i - 1) == s2.charAt(j - 1)){
//                    dp[i][j] = dp[i - 1][j - 1] + 1;
//                    b[i][j] = 1;
//                }else{
//                    if(dp[i - 1][j] > dp[i][j - 1]){
//                        dp[i][j] = dp[i - 1][j];
//                        b[i][j] = 2;
//                    }else{
//                        dp[i][j] = dp[i][j - 1];
//                        b[i][j] = 3;
//                    }
//                }
//            }
//        }
//        s = s1;
//        String ret = dfs(n,m,b);
//        if(ret.isEmpty())return "-1";
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        LCS("ABCBDAB","BDCABA");
//    }
//    public static String trans(String s, int n) {
//        if(n==0)
//            return s;
//        StringBuffer res=new StringBuffer();
//        for(int i = 0; i < n; i++){
//            //大小写转换
//            if(s.charAt(i) <= 'Z' && s.charAt(i) >= 'A')
//                res.append((char)(s.charAt(i) - 'A' + 'a'));
//            else if(s.charAt(i) >= 'a' && s.charAt(i) <= 'z')
//                res.append((char)(s.charAt(i) - 'a' + 'A'));
//            else
//                //空格直接复制
//                res.append(s.charAt(i));
//        }
//        //翻转整个字符串
//        res = res.reverse();
//        for (int i = 0; i < n; i++){
//            int j = i;
//            //以空格为界，二次翻转
//            while(j < n && res.charAt(j) != ' ')
//                j++;
//            String temp = res.substring(i,j);
//            StringBuffer buffer = new StringBuffer(temp);
//            temp = buffer.reverse().toString();
//            res.replace(i,j,temp);
//            i = j;
//        }
//        return res.toString();
//    }
//
//    public static void main(String[] args) {
//        //System.out.println(trans("This is a sample",16));\
//        String s = "123456";
//        StringBuilder s1 = new StringBuilder(s);
//        System.out.println(s.substring(0,5));
//        System.out.println(s1.substring(0,5));
//    }

//
//    public static void main(String[] args) {
//        trans("This is a sample",16);
//        System.out.println('T' - 'A');
//    }
//    public static int rob (int[] nums) {
//        // write code here
//        int n = nums.length;
//        int[] f = new int[n];
//        int[] g = new int[n];
//        f[0] = nums[0];
//        for(int i = 1;i < n;i++){
//            f[i] = g[i - 1] + nums[i];
//            g[i] = Math.max(g[i - 1],f[i - 1]);
//        }
//        return Math.max(g[n - 1],f[n - 1]);
//    }
//
//    public static void main(String[] args) {
//        rob(new int[]{1,3,6});
//    }
//    public static int n;
//    public static ArrayList<ArrayList<Integer>> ret;
//    public static boolean[] vis;
//    public static ArrayList<Integer> l;
//    public static HashSet<String> set = new HashSet<>();
//    public static void dfs(int[] num,int pos){
//        if(pos == n){
//            if(!set.contains(l.toString())){
//                ret.add(new ArrayList<>(l));
//                set.add(l.toString());
//            }
//            return;
//        }
//        for(int i = 0;i < n;i++){
//            if(!vis[i]){
//                vis[i] = true;
//                l.add(num[i]);
//                dfs(num,pos + 1);
//                vis[i] = false;
//                l.remove(l.size() - 1);
//            }
//        }
//    }
//    public ArrayList<ArrayList<Integer>> permuteUnique (int[] num) {
//        // write code here
//        n = num.length;
//        ret = new ArrayList<>();
//        vis = new boolean[n];
//        l = new ArrayList<>();
//        Arrays.sort(num);
//        dfs(num,0);
//        return ret;
//    }
//
//    public static void main(String[] args) {
//        generateParenthesis(1);
//    }
//    public static int[] solve (int[] a) {
//        // write code here
//        int n = a.length,pos = 0,max = n;
//        Stack<Integer> stack = new Stack<>();
//        int[] ret = new int[n];
//        boolean[] hash = new boolean[n + 1];
//        for(int i = 0;i < n;i++){
//            stack.add(a[i]);
//            hash[a[i]] = true;
//            while(!stack.empty() && hash[max]){
//                ret[pos++] = stack.peek();
//                if(max == stack.peek())max--;
//                stack.pop();
//            }
//        }
//        while(!stack.empty())stack.add(stack.pop());
//        return ret;
//    }
//    public static int[] solve (int[] a) {
//        // write code here
//        Stack<Integer> stack = new Stack<>();
//        int n = a.length,j = n - 1,pos = 0;
//        int[] ret = new int[n];
//        int[] in = new int[n];
//        for(int i = 0;i < n;i++)in[i] = a[i];
//        Arrays.sort(in);
//        for(int i = 0;i < n;i++){
//            stack.add(a[i]);
//            while(!stack.empty() && stack.peek() == in[j]){
//                ret[pos++] = stack.pop();
//                j--;
//            }
//        }
//        while(!stack.empty())ret[pos++] = stack.pop();
//        return ret;
//    }

//    public static void main(String[] args) {
//        int[] a = {2,1,5,3,4};
//        System.out.println(Arrays.toString(solve(a)));
//    }
//    public static void main(String[] args) {
//        Scanner in = new Scanner(System.in);
//        int n = in.nextInt();
//        int[][] a = new int[n][2];
//        for(int i = 0;i < n;i++){
//            a[i][0] = in.nextInt();
//            a[i][1] = in.nextInt();
//        }
//        int t = in.nextInt();
//        int[] b = new int[t];
//        for(int i = 0;i < t;i++)b[i] = in.nextInt();
//        HashSet<Long> k1 = new HashSet<>();
//        HashSet<Long> k2 = new HashSet<>();
//        HashSet<Long> col = new HashSet<>();
//        HashSet<Long> row = new HashSet<>();
//        int j = 0;
//        for(int i = 0;i < n;i++){
//            int x = a[i][0],y = a[i][1];
//            if(i == b[j] - 1){
//                if(!k1.contains((long)y - x + 100000000) && !k2.contains((long)y + x) && !row.contains((long)y) && !col.contains((long)x))System.out.println("No");
//                else System.out.println("Yes");
//                j++;
//            }
//            k1.add((long)y - x + 100000000);
//            k2.add((long)y + x);
//            row.add((long)y);
//            col.add((long)x);
//            if(i == 3)
//                if(j == t)break;
//        }
//    }
//    public static void main(String[] args) {
//        Solution solution = new Solution(2);
//        Solution.Node cur = new Solution.Node(-1,-1);
//        System.out.println(cur);
//        System.out.println(new Solution.Node(-1,-1));
//    }

/**
 * Your Solution object will be instantiated and called as such:
 * Solution solution = new Solution(capacity);
 * int output = solution.get(key);
 * solution.set(key,value);
 */
//    public static void rotateCounterClockwise(int[][] array) {
//        int n = array.length;
//        // 先沿中轴线翻转
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n / 2; j++) {
//                int temp = array[i][j];
//                array[i][j] = array[i][n - 1 - j];
//                array[i][n - 1 - j] = temp;
//            }
//        }
//        // 再沿对角线翻转
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < i; j++) {
//                int temp = array[i][j];
//                array[i][j] = array[j][i];
//                array[j][i] = temp;
//            }
//        }
//    }

//    public static void main(String[] args) {
//        int[][] array = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
//        rotateCounterClockwise(array);
//        for (int[] row : array) {
//            System.out.println(Arrays.toString(row));
//        }
//    }
//    public static void main(String[] args) {
//        Solution solution = new Solution();
//        int[][] mat = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
//        int[][] rotated = solution.rotateMatrix(mat, 3);
//        for (int[] row : rotated) {
//            System.out.println(Arrays.toString(row));
//        }
//    }

//    public static void main(String[] args) {
//        List<Integer> list = new ArrayList<Integer>();
//        list.add(-453354);
//        list.add(-453354);
//        int x = list.get(0);
//        int y = list.get(1);
//        System.out.println(list.get(0) != list.get(1));
//        System.out.println(x != y);
//    }
}